package com.yt.system.service.impl;

import com.yt.system.dao.UserMapper;
import com.yt.system.domain.*;
import com.yt.system.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import com.yt.system.utils.RandomNumberListUtil;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 高铭
 * @date 2019/9/19 - 11:16
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;
    /**
     * 查询所有的用户
     * @return 返回全部用户的姓名以及用户总人数
     */
    @Override
    public List<User> adminFindAllUser() {
        return userMapper.adminFindAllUser();
    }
    /**
     * 管理员对全部人员随机分组
     * @param groupTotalNum
     * @param eachGroupPeople
     * @param userList
     * @return
     */
    @Override
    public Map<String, Object> adminRandomToAllGroup(Integer groupTotalNum, Integer eachGroupPeople, List<User> userList) {

        //随机分组时候，将上周的分组信息表状态设置为1(代表过去的)
        userMapper.updateGroupMessageStatus();
        //将组别表的状态更改为1，代表组别表的信息过去了
        userMapper.updateGroupTableStatus();
        //得到总人数
        int totalPeople = userList.size();
        //得到随机分组的号码序列
        List<Integer> randomList = RandomNumberListUtil.getRandomList(totalPeople);
        //如果管理员制定要分多少个组,但是每个组的人员没确定
        if(groupTotalNum != null && eachGroupPeople == null){
            Map<String, Object> msgMap = insertUserAndGroupMsg(randomList, groupTotalNum, userList);
            return msgMap;
        }
        //如果管理员制定一个组要分多少个人，但是没有确定要分多少各组
        if(eachGroupPeople != null && groupTotalNum == null){
            //定义小组的总数,总人数取模，得到一个数，剩余人数依次插入不同组别中，并且是每次每组插一个
            if(eachGroupPeople >= totalPeople){
                //如果管理员输入的一组要多少人，大于总人数的话，就默认分一个组
                groupTotalNum = 1;
                Map<String, Object> msgMap = insertUserAndGroupMsg(randomList, groupTotalNum, userList);
                return msgMap;
            }else{
                //管理员输入的一组要多少个人少于总数量的时候，再算得到多少的组
                groupTotalNum = totalPeople / eachGroupPeople ;
                Map<String, Object> msgMap = insertUserAndGroupMsg(randomList, groupTotalNum, userList);
                return msgMap;
            }
        }
        //如果管理员明确小组总数量以及每个组要分多少个人
        if(eachGroupPeople != null && groupTotalNum != null){
            //当管理员分别输入要分的小组总数量，以及一组要多少个人的时候
            Map<String, Object> map = new HashMap<>();
            map.put("code",-1);
            map.put("msg","您输入有误");
            return map;
        }
        return null;
    }

    /**
     * 分组后将新的组信息插进group_account表中
     * @param groupTotalNum
     */
    @Override
    public void insertGroupAccount(Integer groupTotalNum) {
        for(int i = 1 ; i <= groupTotalNum ; i++){
            GroupAccount groupAccount = new GroupAccount();
            //设置组别
            groupAccount.setGid(i);
            //默认设置组别信息
            groupAccount.setGname("第"+i+"组");
            //默认给这些组设置的总积分是0分
            groupAccount.setGscore(0d);
            userMapper.insertGroupAccount(groupAccount);
        }
    }

    /**
     * 将用户数据以及对应的组别存进数据库的独立方法
     * @param randomList
     * @param groupTotalNum
     * @param userList
     * @return
     */
    public Map<String,Object> insertUserAndGroupMsg(List<Integer> randomList,Integer groupTotalNum,List<User> userList) {
        Map<String, Object> msgMap = new HashMap<>();
        Map<User, Integer> map = RandomNumberListUtil.mapList(randomList, groupTotalNum, userList);
        for (int gid = 1; gid <= groupTotalNum; gid++) {
            System.out.println("第" + gid + "组人员：");
            for (User user : map.keySet()) {
                if (map.get(user) == gid) {
                    System.out.print(user.getUid() + ":" + user.getUname() + " " + gid + " ");
                    //其中 i 代表是组别，user是代表目前i组别的人员
                    //携带 组别 i 以及 uid 去操作数据，保存随机分组后组员和组别的关系
                    userMapper.adminRandomToAllGroup(user.getUid(),gid);
                }
            }
            System.out.println();
        }
        msgMap.put("msg", "随机分组成功");
        msgMap.put("code", 0);
        return msgMap;
    }

    /**
     * 查询所有用户信息
     * @return
     */
    @Override
    public List<User> getAllUser() {
        return userMapper.getAllUser();
    }

    /**
     * 根据用户ID查询用户信息
     * @param uid
     * @return
     */
    @Override
    public User selectByPrimaryKey(Integer uid) {
        return userMapper.selectByPrimaryKey(uid);
    }

    /**
     * 根据用户ID有选择的更改用户信息
     * @param record
     * @return
     */
    @Override
    public int updateByPrimaryKeySelective(User record) {
        System.out.println(record.toString());
        return userMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public User selectByEmail(String uemail) {
        User user = userMapper.selectByEmail(uemail);
        return user;
    }

    /**
     * 查找除自己之外的当前小组的其他人员信息
     * @param uid
     * @param gid
     * @return
     */
    @Override
    public List<User> getGroupOtherUser(Integer uid, Integer gid) {
        return userMapper.getGroupOtherUser(uid,gid);
    }

    /**
     * 组长为组别添加口号和组别名称
     * @param groupTable
     */
    @Override
    public void leaderInsertGroupMsg(GroupTable groupTable) {
        userMapper.leaderInsertGroupMsg(groupTable);
    }

    @Override
    public List<Integer> getAllTheGid() {
        return userMapper.getAllTheGid();
    }

    /**
     * 返回组别的人员信息
     * @param gidList
     * @return
     */
    @Override
    public Map<String, Object> getGroupAndPeopleMsg(List<Integer> gidList) {
        Map<String,Object> map = new HashMap<>();
        for (Integer gid : gidList) {
            /*List<GroupTable> groupTableList = userMapper.getGroupTableMsg(gid);*/
            List<UserAndRoleMsg> userAndRoleMsgList = userMapper.UserAndRoleMsg(gid);
            for (UserAndRoleMsg roleMsg : userAndRoleMsgList) {
                roleMsg.setGid(gid);
            }
            /*map.put("groupTableList"+gid,groupTableList);*/
            map.put("userAndRoleMsgList"+gid,userAndRoleMsgList);
        }
        return map;
    }

    /**
     * 选好并确认组长
     * @param uid
     * @param gid
     */
    @Override
    public void sureGroupLeader(Integer uid, Integer gid) {
        userMapper.sureGroupLeader(uid,gid);
    }

    @Override
    public void deleteGroupLeader(Integer gid) {
        userMapper.deleteGroupLeader(gid);
    }

    @Override
    public GroupTable getGroupTable(Integer gid) {
        return userMapper.getGroupTable(gid);
    }

    @Override
    public List<User> getGroupTableList(Integer gid) {
        return userMapper.getGroupTableList(gid);
    }

    @Override
    public void updateGroupMessageStatus() {
        userMapper.updateGroupTableStatus();
    }

    /**
     * 对某个组进行组别重置，将这个组别的状态修改成为历史
     * @param gid
     */
    @Override
    public void resetTheGroup(Integer gid) {
        //对某个组进行组别重置，将这个组别的状态修改成为历史
        userMapper.resetTheGroup(gid);
        //修改这个组别的分数为0
        userMapper.updateGroupAccount(gid);
    }

    /**
     * 修改这组人员的  组别--人员 状态,代表将这组人员的信息状态改变为过去
     * @param gid
     */
    @Override
    public void resetTheGroupPeopleMsg(Integer gid) {
        userMapper.resetTheGroupPeopleMsg(gid);
    }

    /**
     * 对某个人进行组别重置（将这个人从组别中移除出去）
     * @param uid
     * @param gid
     * @return
     */
    @Override
    public int resetTheGroupOnePeople(Integer uid, Integer gid) {
        return userMapper.resetTheGroupOnePeople(uid,gid);
    }

    @Override
    public void deleteUserRole() {
        //将用户-角色表的数据全部删除（保留管理员以及超级管理员的数据），避免选出组长出现数据重复（与上周冲突）
        userMapper.deleteUserRole();
        //清除所有的组别账号排名表 group_account
        userMapper.delGroupAccount();
    }

    @Override
    public void deleteUserRoleByGid(Integer gid) {
        userMapper.deleteUserRoleByGid(gid);
    }

    @Override
    public void leaderUpdateGroupMsg(GroupTable groupTable) {
        userMapper.leaderUpdateGroupMsg(groupTable);
    }

    /**
     * 判断用户是否是组长
     * @param uid
     * @param gid
     * @return
     */
    @Override
    public UserRole userIsLeader(Integer uid, Integer gid) {
        return userMapper.userIsLeader(uid,gid);
    }

    @Override
    public UserRole groupIsHaveLeader(Integer gid) {
        return userMapper.groupIsHaveLeader(gid);
    }

    @Override
    public void saveUserToUserTemplate(Integer uid) {
        //先查询出重置这个人员的信息
        User user = userMapper.getUserByUid(uid);
        userMapper.saveUserToUserTemplate(user);
    }

    @Override
    public void saveAllPeopleToUserTemplate(Integer gid) {
        //通过组id去得到当周有效组的所以组员
        List<User> userList = userMapper.getUserByGid(gid);
        for (User user : userList) {
            userMapper.saveUserToUserTemplate(user);
        }
    }

    /**
     * 查找重置分组之后处于没安排组别状态的所有人员
     * @return
     */
    @Override
    public List<User> findAllNoInGroupPeople() {
        return userMapper.findAllNoInGroupPeople();
    }

    /**
     * 将某个重置分组之后处于没安排组别状态的人员拉进具体的组别里
     * @param uid
     * @param gid
     */
    @Override
    public void pullPeopleToGroup(Integer uid, Integer gid) {
        //将某个重置分组之后处于没安排组别状态的人员拉进具体的组别里
        userMapper.pullPeopleToGroup(uid,gid);
        //然后将这个人在usertemplate表中删除这个人员信息
        userMapper.delPeopleFromUserTemplateByUid(uid);
    }


    @Override
    public int insertSelective(User record) {
        return userMapper.insertSelective(record);
    }

    /**
     * 管理员对所有人重置组别时候，删除用户临时表
     */
    @Override
    public void delUserTemplate() {
        userMapper.delUserTemplate();
        userMapper.updateGroupMessageStatus();
    }

    @Override
    public int saveImg(Integer uid,String img) {
        return userMapper.saveImg(uid,img);
    }
}
